home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / rpc / rpcByteSwap.c < prev    next >
C/C++ Source or Header  |  1992-12-18  |  6KB  |  202 lines
  1. /*
  2.  * rpcByteSwap.c --
  3.  *
  4.  *    The code to byte swap incoming rcp headers and parameter blocks.
  5.  *
  6.  * Copyright 1988 Regents of the University of California
  7.  * Permission to use, copy, modify, and distribute this
  8.  * software and its documentation for any purpose and without
  9.  * fee is hereby granted, provided that the above copyright
  10.  * notice appear in all copies.  The University of California
  11.  * makes no representations about the suitability of this
  12.  * software for any purpose.  It is provided "as is" without
  13.  * express or implied warranty.
  14.  */
  15.  
  16. #ifndef lint
  17. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/rpc/rpcByteSwap.c,v 9.4 91/09/10 18:43:05 rab Exp $ SPRITE (Berkeley)";
  18. #endif /* not lint */
  19.  
  20.  
  21. #include <sprite.h>
  22. #include <stdio.h>
  23. #include <net.h>
  24. #include <rpcInt.h>
  25. #include <rpcPacket.h>
  26.  
  27. /*
  28.  * Global var for testing byte-swapping.  Causes out-going messages to
  29.  * be byte-swapped, so that the receiving machine must byte-swap them if
  30.  * it is of the same sort.
  31.  */
  32. Boolean    rpcTestByteSwap = FALSE;
  33.  
  34.  
  35. /*
  36.  *----------------------------------------------------------------------
  37.  *
  38.  * RpcByteSwapBuffer --
  39.  *
  40.  *    Byte swap the given buffer integer-by-integer.
  41.  *    Byte swapping means taking an integer of the form 0x61626364 and
  42.  *    turning it into 0x64636261.
  43.  *
  44.  * Results:
  45.  *    None.
  46.  *
  47.  * Side effects:
  48.  *    The buffer is byte-swapped.
  49.  *
  50.  *----------------------------------------------------------------------
  51.  */
  52. void
  53. RpcByteSwapBuffer(bufferPtr, numInts)
  54.     register int *bufferPtr;
  55.     register int numInts;
  56. {
  57.     register unsigned int in;
  58.  
  59. #define    LOW_BYTE_MASK        0x000000ff
  60. #define    MIDDLE_LOW_BYTE_MASK    0x0000ff00
  61. #define    MIDDLE_HIGH_BYTE_MASK    0x00ff0000
  62. #define    HIGH_BYTE_MASK        0xff000000
  63.  
  64. #ifdef lint
  65.     while (numInts > 0) {
  66.     --numInts;
  67. #else    
  68.     while (--numInts >= 0) {
  69. #endif    
  70.     in = *bufferPtr;
  71.     *bufferPtr++ =   ((in << 8)  & MIDDLE_HIGH_BYTE_MASK)
  72.                    | ((in << 24) & HIGH_BYTE_MASK)
  73.                | ((in >> 8)  & MIDDLE_LOW_BYTE_MASK)
  74.                | ((in >> 24) & LOW_BYTE_MASK);
  75.     }
  76.     return;
  77. }
  78.  
  79.  
  80.  
  81. /*
  82.  *----------------------------------------------------------------------
  83.  *
  84.  * RpcByteSwapInComing --
  85.  *
  86.  *    Byte swap the in-coming rpc packet header and the following parameter
  87.  *    block, integer-by-integer.  The data block is not byte swapped.
  88.  *    It knows the RPC packet format:
  89.  *        The Rpc header, which includes the sizes of the next two parts.
  90.  *        The parameter area.
  91.  *        The data area.
  92.  *    Byte swapping means taking an integer of the form 0x61626364 and turning
  93.  *    it into 0x64636261.
  94.  *
  95.  * Results:
  96.  *    TRUE if successful, FALSE if not.  Maybe this should require a more
  97.  *    interesting set of return values, but Rpc_Dispatch just drops the
  98.  *    packet if this routine returns FALSE.
  99.  *
  100.  * Side effects:
  101.  *    The header packet structure and the parameter block are byte-swapped.
  102.  *
  103.  *----------------------------------------------------------------------
  104.  */
  105. Boolean
  106. RpcByteSwapInComing(rpcHdrPtr, packetLength)
  107.     RpcHdr    *rpcHdrPtr;        /* The Rpc Header as it sits in the
  108.                      * network's buffer.  The data follows
  109.                      * the header directly. */
  110.     int        packetLength;        /* Length of the network packet. */
  111. {
  112.     int    numInts;
  113.     int    paramSize;
  114.  
  115.     /*
  116.      * First byte-swap the rpc header itself.  The header had better be an
  117.      * integral number of integers long!
  118.      */
  119.     numInts = sizeof (RpcHdr) / sizeof (int);
  120.     if ((sizeof (RpcHdr) % sizeof (int)) != 0) {
  121.     return FALSE;
  122.     }
  123.     RpcByteSwapBuffer((int *) rpcHdrPtr, numInts);
  124.  
  125.     /* now that we've got the right values */
  126.     paramSize = rpcHdrPtr->paramSize;
  127.  
  128.     /*
  129.      * Make sure the parameter block is all there.
  130.      */
  131.     if (packetLength < sizeof(RpcHdr) + rpcHdrPtr->paramSize) {
  132.     printf("RpcByteSwapInComing: SHORT packet %d < %d, ", 
  133.         packetLength, sizeof(RpcHdr) + rpcHdrPtr->paramSize);
  134.     printf("srv %d clt %d rpc %d\n", rpcHdrPtr->serverID,
  135.             rpcHdrPtr->clientID, rpcHdrPtr->command);
  136.     return FALSE;
  137.     }
  138.     /*
  139.      * Now byte-swap the parameter block.  If it isn't an integral number of
  140.      * integers long, something is wrong.
  141.      */
  142.     numInts = paramSize / sizeof (int);
  143.     if ((paramSize % sizeof (int)) != 0) {
  144.     printf("RpcByteSwapInComing: bad paramSize %d, ", paramSize);
  145.     printf("srv %d clt %d rpc %d\n", rpcHdrPtr->serverID,
  146.             rpcHdrPtr->clientID, rpcHdrPtr->command);
  147.     return FALSE;
  148.     }
  149.     /*
  150.      * We don't add on paramOffset here, since the parameter area, even if
  151.      * it's a fragment, immediately follows the rpcHdr for the fragment.
  152.      */
  153.     RpcByteSwapBuffer((int *) (((char *) rpcHdrPtr) + sizeof (RpcHdr)),
  154.         numInts);
  155.  
  156.     return TRUE;
  157. }
  158.  
  159. /*
  160.  *----------------------------------------------------------------------
  161.  *
  162.  * RpcPrintHdr --
  163.  *
  164.  *    Print out fields from the given header.
  165.  *
  166.  * Results:
  167.  *    None.
  168.  *
  169.  * Side effects:
  170.  *    printf is invoked.
  171.  *
  172.  *----------------------------------------------------------------------
  173.  */
  174. void
  175. RpcPrintHdr(rpcHdrPtr)
  176.     RpcHdr    *rpcHdrPtr;        /* The Rpc Header as it sits in the
  177.                      * network's buffer.  The data follows
  178.                      * the header directly. */
  179. {
  180.  
  181.     printf("\tversion(X): %x\n\tflags(X): %x\n\tclientID(D): %d\n",
  182.         rpcHdrPtr->version, rpcHdrPtr->flags, rpcHdrPtr->clientID);
  183.         printf("\tcommand(D): %d\n\tparamSize(X): %x\n", rpcHdrPtr->command,
  184.         rpcHdrPtr->paramSize);
  185.         printf("\tparamOffset(X): %x\n", rpcHdrPtr->paramOffset);
  186.     return;
  187. }
  188.  
  189. int
  190. RpcSetTestByteSwap()
  191. {
  192.     rpcTestByteSwap = 1;
  193.     return 0;
  194. }
  195.  
  196. int
  197. RpcUnsetTestByteSwap()
  198. {
  199.     rpcTestByteSwap = 0;
  200.     return 0;
  201. }
  202.